//package ws;
//
//import java.io.IOException;
//import java.util.*;
//import java.util.function.Function;
//import java.util.stream.Collectors;
//
///**
// * todo
// *
// * @author zhengshan
// * @Date 2022/5/13 16:55
// */
//public class CeLue {
//
//    /**
//     * 根据主数据集合对象生成主数据（包含增强动作）
//     *
//     * @param context 主数据集合对象
//     * @return 主数据对象
//     * @throws Exception 主数据定义异常
//     * @date 2018-05-16 23:53:00
//     */
//    public <T> List<T> query(MasterDataQueryContext context, MasterDataQueryCondition condition) throws Exception {
//
//        // 如果请求对象为空,抛出异常
//        if (context.getRequest() == null) {
//            throw new MasterDataBaseException(MasterDataQueryMsgConsts.HMDM_CORE_QUEY_ERROR_001);
//        }
//
//        // 如果策略模式为空，则默认使用DEFAULT模式
//        if (StringUtils.isEmpty(context.getQueryStrategyType())) {
//            context.setQueryStrategyType("DEFAULT");
//        }
//
//        //获取系统增强
//        MasterDataQueryEnhancer defaultEnhancer = enhancerMaps.get("DEFAULT");
//        MasterDataQueryEnhancer customEnhancer = enhancerMaps.get(context.getMdTypeCode());
//        //获取客制化增强
//        condition = defaultEnhancer.preQuery(context, condition);
//
//        //执行客制化的主数据增强方法
//        if (customEnhancer != null) {
//            condition = customEnhancer.preQuery(context, condition);
//        }
//
//        // 策略工厂获取需要策略类，执行策略类的post方法
//        List<Map<String, Object>> masterDatamaps = masterDataQueryFactory.getQueryStrategy(context.getQueryStrategyType()).query(context, condition);
//        //执行默认的主数据增强方法
//        List<T> convertedDto = defaultEnhancer.afterQuery(context, condition, masterDatamaps);
//
//        //执行客制化的主数据增强方法
//        if (customEnhancer != null) {
//            convertedDto = customEnhancer.afterQuery(context, condition, convertedDto);
//        }
//
//        return convertedDto;
//    }
//
//    /**
//     * 主数据查询预处理方法
//     *
//     * @param context 主数据查询上下文
//     * @param condition 主数据查询条件
//     * @return MasterDataCondition 处理后的查询条件
//     * @throws Exception 异常
//     */
//    public MasterDataQueryCondition preQuery(MasterDataQueryContext context, MasterDataQueryCondition condition) throws Exception {
//        return condition;
//    }
//
//    /**
//     * 查询入口
//     *
//     * @param context   查询上下文
//     * @param condition 查询条件
//     * @return 主数据ListMap
//     * @throws BaseException 异常
//     */
//    public List<Map<String, Object>> query(MasterDataQueryContext context, MasterDataQueryCondition condition) throws Exception {
//        // 预分页查询处理
//        if (!this.prePageQuery(context, condition)) {
//            return new ArrayList<>();
//        }
//        // 初始化常用信息，创建内部使用对象
//        MasterDataQueryInternal queryInternal = new MasterDataQueryInternal();
//        this.initQuery(context, condition, queryInternal);
//        // 核心转换逻辑
//        // 转换表，列及关联join信息
//        this.parseTablesAndColumns(context, condition, queryInternal);
//        // 查询列进一步按需筛选
//        this.parseQueryColumns(context, condition, queryInternal);
//        // 转换限制条件信息
//        this.parseRestrictions(context, condition, queryInternal);
//        // 转换排序条件信息
//        this.parseQueryOrder(context, condition, queryInternal);
//        // 转换关联表信息
//        this.parseJoinTableInfo(context, condition, queryInternal);
//        // 执行查询并返回
//        return this.processQuery(context, condition, queryInternal);
//    }
//
//
//    /**
//     * 内部转换查询表及字段
//     * 1. 转换表（from）集合
//     * 2. 转换字段(select)集合
//     * 3. 转换表之间的join集合
//     *
//     * @param context       查询上下文
//     * @param condition     查询条件
//     * @param queryInternal 查询内部对象
//     * @throws BaseException 异常
//     */
//    private void parseTablesAndColumns(MasterDataQueryContext context, MasterDataQueryCondition condition, MasterDataQueryInternal queryInternal) throws BaseException {
//        // 1. 处理QUERY_ALL的代码集合
//        // 1.1 处理组织分配QUERY_ALL
//        Set<String> allOrgTypeCodes = MasterDataQueryUtils.getOrgTypeCodes(context.getMasterDataAttrs());
//        if (CollectionUtils.isNotEmpty(context.getQueryOrgTypeCodes())) {
//            // 如果启用了查询所有，则初始化所有组织分配类型
//            if (context.getQueryOrgTypeCodes().contains(MasterDataQueryConstants.QUERY_ALL)) {
//                context.getQueryOrgTypeCodes().clear();
//                context.getQueryOrgTypeCodes().addAll(allOrgTypeCodes);
//            }
//        }
//        // 1.2 处理动态属性表QUERY_ALL
//        Set<String> allTableAttrCodes = MasterDataQueryUtils.getTableAttrCodes(context.getMasterDataAttrs());
//        if (CollectionUtils.isNotEmpty(context.getQueryTableAttrCodes())) {
//            // 如果启用了查询所有，则初始化所有组织分配类型
//            if (context.getQueryTableAttrCodes().contains(MasterDataQueryConstants.QUERY_ALL)) {
//                context.getQueryTableAttrCodes().clear();
//                context.getQueryTableAttrCodes().addAll(allTableAttrCodes);
//            }
//        }
//        // 1.3 处理附件QUERY_ALL
//        Set<String> allAttachOrgTypeCodes = MasterDataQueryUtils.getAttachOrgTypeCodes(context.getAttachmentTypes());
//        if (CollectionUtils.isNotEmpty(context.getQueryAttachOrgTypeCodes())) {
//            // 如果查询所有
//            if (context.getQueryAttachOrgTypeCodes().contains(MasterDataQueryConstants.QUERY_ALL)) {
//                context.getQueryAttachOrgTypeCodes().clear();
//                context.getQueryAttachOrgTypeCodes().addAll(allAttachOrgTypeCodes);
//            }
//        }
//        // 1.3.1 处理InnerJoinc的QUERY_ALL
//        if (CollectionUtils.isNotEmpty(context.getEnableInnerQueryCodes())) {
//            List<MasterDataUniqueAttr> queryAllInnerQueryCodes = context.getEnableInnerQueryCodes().stream().filter(a -> MasterDataQueryConstants.QUERY_ALL.equals(a.getOrgTypeCode())
//                    || MasterDataQueryConstants.QUERY_ALL.equals(a.getTableAttrCode())).collect(Collectors.toList());
//            if (CollectionUtils.isNotEmpty(queryAllInnerQueryCodes)) {
//                for (MasterDataUniqueAttr allInnerQueryCode : queryAllInnerQueryCodes) {
//                    if (MasterDataQueryConstants.TABLE_LEVEL_MD_ORG.equals(allInnerQueryCode.getTableLevel())) {
//                        if (CollectionUtils.isNotEmpty(allOrgTypeCodes)) {
//                            allOrgTypeCodes.forEach(orgTypeCode -> {
//                                context.enableOrgInnerQueryCode(orgTypeCode);
//                            });
//                        }
//                    } else if (MasterDataQueryConstants.TABLE_LEVEL_MD_TABLE_ATTR.equals(allInnerQueryCode.getTableLevel())) {
//                        if (CollectionUtils.isNotEmpty(allTableAttrCodes)) {
//                            allTableAttrCodes.forEach(tableAttrCode -> {
//                                context.enableTableAttrInnerQueryCode(tableAttrCode);
//                            });
//                        }
//                    }
//                }
//                context.getEnableInnerQueryCodes().removeAll(queryAllInnerQueryCodes);
//            }
//        }
//
//        // 1.4 处理查询列中的QUERY_ALL的代码集合
//        // 如果层级指定了ALL，则自动补充的查询信息
//        // a. 组织类型层；b. 动态属性层；c. 附件层
//        // 转换完后进行删除老记录
//        if (CollectionUtils.isNotEmpty(condition.getMdQueryColumns())) {
//            List<MasterDataQueryColumn> queryAllColumns = condition.getMdQueryColumns().stream().filter(a -> (a.getOrgTypeCode().equals(MasterDataQueryConstants.QUERY_ALL)
//                    || a.getTableAttrCode().equals(MasterDataQueryConstants.QUERY_ALL))).collect(Collectors.toList());
//            if (queryAllColumns != null && queryAllColumns.size() > 0) {
//                for (MasterDataQueryColumn queryColumn : queryAllColumns) {
//                    if (queryColumn.getTableLevel().equals(MasterDataQueryConstants.TABLE_LEVEL_MD_ORG)) {
//                        for (String orgTypeCode : allOrgTypeCodes) {
//                            condition.addOrgQueryColumn(orgTypeCode, queryColumn.getColumnNames());
//                        }
//                    } else if (queryColumn.getTableLevel().equals(MasterDataQueryConstants.TABLE_LEVEL_MD_TABLE_ATTR)) {
//                        for (String tableAttrCode : allTableAttrCodes) {
//                            condition.addTableAttrQueryColumn(tableAttrCode, queryColumn.getColumnNames());
//                        }
//                    } else if (queryColumn.getTableLevel().equals(MasterDataQueryConstants.TABLE_LEVEL_MD_ATTACHMENT)) {
//                        for (String attachOrgTypeCode : allAttachOrgTypeCodes) {
//                            condition.addAttachQueryColumn(attachOrgTypeCode, queryColumn.getColumnNames());
//                        }
//                    }
//                }
//                condition.getMdQueryColumns().removeAll(queryAllColumns);
//            }
//        }
//        // 1.5 处理限制条件中的QUERY_ALL
//        List<List<MasterDataConditionAttr>> totalConditionAttrs = new ArrayList<>();
//        totalConditionAttrs.add(condition.getMdConditionAttrs());
//        totalConditionAttrs.add(condition.getSolrConditionAttrs());
//        for (List<MasterDataConditionAttr> conditionAttrs : totalConditionAttrs) {
//            if (CollectionUtils.isNotEmpty(conditionAttrs)) {
//                // 1.5.1 组织类型QUERY_ALL：如果存在组织类型QUERY_ALL, 则进行全部匹配
//                List<MasterDataConditionAttr> queryAllConditions = conditionAttrs.stream().filter(a -> a.getOrgTypeCode().equals(MasterDataQueryConstants.QUERY_ALL)).collect(Collectors.toList());
//                if (CollectionUtils.isNotEmpty(queryAllConditions)) {
//                    MasterDataConditionAttr newConditionAttr = null;
//                    for (MasterDataConditionAttr conditionAttr : queryAllConditions) {
//                        /**
//                         * 两种层有组织类型代码，组织类型层和附件层
//                         */
//                        if (conditionAttr.getTableLevel().equals(MasterDataQueryConstants.TABLE_LEVEL_MD_ORG)) {
//                            for (String orgTypeCode : allOrgTypeCodes) {
//                                newConditionAttr = CloneUtils.deepCopy(conditionAttr);
//                                newConditionAttr.setOrgTypeCode(orgTypeCode);
//                                conditionAttrs.add(newConditionAttr);
//                            }
//                        } else if (conditionAttr.getTableLevel().equals(MasterDataQueryConstants.TABLE_LEVEL_MD_ATTACHMENT)) {
//                            for (String attachOrgTypeCode : allAttachOrgTypeCodes) {
//                                newConditionAttr = CloneUtils.deepCopy(conditionAttr);
//                                newConditionAttr.setOrgTypeCode(attachOrgTypeCode);
//                                conditionAttrs.add(newConditionAttr);
//                            }
//                        }
//                    }
//                    // 删除ALL
//                    conditionAttrs.removeAll(queryAllConditions);
//                }
//                // 1.5.2 动态属性表QUERY_ALL：如果存在QUERY_ALL，则匹配所有动态属性表
//                queryAllConditions = conditionAttrs.stream().filter(a -> (a.getTableAttrCode().equals(MasterDataQueryConstants.QUERY_ALL)
//                        && a.getTableLevel().equals(MasterDataQueryConstants.TABLE_LEVEL_MD_TABLE_ATTR))).collect(Collectors.toList());
//                if (CollectionUtils.isNotEmpty(queryAllConditions)) {
//                    MasterDataConditionAttr newConditionAttr = null;
//                    for (MasterDataConditionAttr conditionAttr : queryAllConditions) {
//                        for (String tableAttrCode : allTableAttrCodes) {
//                            newConditionAttr = CloneUtils.deepCopy(conditionAttr);
//                            newConditionAttr.setTableAttrCode(tableAttrCode);
//                            conditionAttrs.add(newConditionAttr);
//                        }
//                    }
//                    // 删除ALL
//                    conditionAttrs.removeAll(queryAllConditions);
//                }
//            }
//        }
//
//        // 2. 处理条件中内置代码集合
//        // 2.1 查询字段
//        if (CollectionUtils.isNotEmpty(condition.getMdQueryColumns())) {
//            for (MasterDataQueryColumn queryColumn : condition.getMdQueryColumns()) {
//                // 所有符合条件的组织类型代码，都添加到组织类型代码集合
//                if (StringUtils.isNotBlank(queryColumn.getOrgTypeCode())) {
//                    // 特殊的，处理附件层级组织类型代码，排除附件头默认的组织类型
//                    if (queryColumn.getTableLevel().equals(MasterDataQueryConstants.TABLE_LEVEL_MD_ATTACHMENT)) {
//                        // 将附件所属组织类型代码添加到查询集合中
//                        context.addQueryAttachOrgTypeCodes(queryColumn.getOrgTypeCode());
//                        if (queryColumn.getOrgTypeCode().equals(MasterDataQueryConstants.ATTACH_LEVEL_MD)) {
//                            continue;
//                        }
//                    }
//                    context.addQueryOrgTypeCodes(queryColumn.getOrgTypeCode());
//                } else if (StringUtils.isNotBlank(queryColumn.getTableAttrCode())) {
//                    // 将动态属性代码添加到查询集合中
//                    context.addQueryTableAttrCodes(queryColumn.getTableAttrCode());
//                }
//            }
//        }
//
//        // 3. 如果启用了表结构缓存，则直接获取；提升查询效率
//        String cacheTableKey = context.getQueryStrategyType() + "." + context.getMdTypeCode();
//        List<MasterDataQueryTable> queryTables = null;
//        if ("Y".equals(context.getMasterDataType().getCacheQueryTables())) {
//            queryTables = cacheQueryTables.get(cacheTableKey);
//        }
//
//        // 4. 如果不存在主数据表信息，则先生成表信息
//        if (queryTables == null) {
//            queryTables = new ArrayList<>();
//            // 4.1 生成申请单表
//            if (context.getQueryStrategyType().equals(MasterDataQueryConstants.QUERY_STRATRGY_TYPE_APPLY)) {
//                queryTables.add(this.convertQueryTable(context, condition, queryInternal, MasterDataQueryConstants.TABLE_LEVEL_APPLY, null, null, 0));
//            }
//
//            // 4.2 生成主数据头表
//            queryTables.add(this.convertQueryTable(context, condition, queryInternal, MasterDataQueryConstants.TABLE_LEVEL_MD, null, null, 0));
//
//            // 4.3 生成组织层表
//            int orgTypeNum = 0;
//            for (String orgTypeCode : allOrgTypeCodes) {
//                queryTables.add(this.convertQueryTable(context, condition, queryInternal, MasterDataQueryConstants.TABLE_LEVEL_MD_ORG, orgTypeCode, null, orgTypeNum));
//                orgTypeNum++;
//            }
//            // 4.4 生成动态属性表
//            int tableAttrNum = 0;
//            for (String tableAttrCode : allTableAttrCodes) {
//                queryTables.add(this.convertQueryTable(context, condition, queryInternal, MasterDataQueryConstants.TABLE_LEVEL_MD_TABLE_ATTR, null, tableAttrCode, tableAttrNum));
//                tableAttrNum++;
//            }
//            // 4.5 生成附件表
//            int attachNum = 0;
//            for (String attachOrgTypeCode : allAttachOrgTypeCodes) {
//                queryTables.add(this.convertQueryTable(context, condition, queryInternal, MasterDataQueryConstants.TABLE_LEVEL_MD_ATTACHMENT, attachOrgTypeCode, null, attachNum));
//                attachNum++;
//            }
//            if ("Y".equals(context.getMasterDataType().getCacheQueryTables())) {
//                cacheQueryTables.put(cacheTableKey, queryTables);
//            }
//        }
//        // 5. 将查询表信息设置到条件中
//        if ("Y".equals(context.getMasterDataType().getCacheQueryTables())) {
//            condition.setMdQueryTables(CloneUtils.deepCopy(queryTables));
//        } else {
//            if ("C".equals(context.getMasterDataType().getCacheQueryTables())) {
//                if (cacheQueryTables.containsKey(cacheTableKey)) {
//                    cacheQueryTables.remove(cacheTableKey);
//                }
//            }
//            condition.setMdQueryTables(queryTables);
//        }
//        // 5.1 初始化表属性和表的映射关系
//        for (MasterDataQueryTable queryTable : condition.getMdQueryTables()) {
//            queryInternal.getTableAttrMap().put(queryTable.getMatchUnique(), queryTable);
//            convertQueryTableMap(queryInternal.getTableAliasMap(), queryTable);
//        }
//
//        // 6. 对于不启用查询的，设置为Exists
//        List<MasterDataUniqueAttr> nonSelectTableCodes = new ArrayList<>();
//        // 6.1 针对申请单
//        if (context.getQueryStrategyType().equals(MasterDataQueryConstants.QUERY_STRATRGY_TYPE_APPLY)) {
//            if (context.isQueryApplyEnabled()) {
//                // 6.1.1 如果启用了查询，则增加主数据类型限制条件
//                condition.addApplyQueryCondition("MD_TYPE_CODE", MasterDataQueryConstants.QUERY_CONDITION_TYPE_EQUALS, context.getMasterDataType().getMdTypeCode());
//            } else {
//                nonSelectTableCodes.add(new MasterDataUniqueAttr(MasterDataQueryConstants.TABLE_LEVEL_APPLY, null, null));
//            }
//        }
//        // 6.2 针对主数据头
//        if (!context.isQueryMdEnabled()) {
//            nonSelectTableCodes.add(new MasterDataUniqueAttr(MasterDataQueryConstants.TABLE_LEVEL_MD, null, null));
//        }
//        // 6.3 补充不在查询范围内的组织类型代码
//        allOrgTypeCodes.removeAll(context.getQueryOrgTypeCodes());
//        for (String looseOrgTypeCode : allOrgTypeCodes) {
//            nonSelectTableCodes.add(new MasterDataUniqueAttr(MasterDataQueryConstants.TABLE_LEVEL_MD_ORG, looseOrgTypeCode, null));
//        }
//        // 6.4 补充不在查询范围内的动态属性代码
//        allTableAttrCodes.removeAll(context.getQueryTableAttrCodes());
//        for (String conditionTableAttrCode : allTableAttrCodes) {
//            nonSelectTableCodes.add(new MasterDataUniqueAttr(MasterDataQueryConstants.TABLE_LEVEL_MD_TABLE_ATTR, null, conditionTableAttrCode));
//        }
//        // 6.5 补充不在查询范围内的附件组织类型代码
//        allAttachOrgTypeCodes.removeAll(context.getQueryAttachOrgTypeCodes());
//        for (String conditionAttachOrgTypeCode : allAttachOrgTypeCodes) {
//            nonSelectTableCodes.add(new MasterDataUniqueAttr(MasterDataQueryConstants.TABLE_LEVEL_MD_ATTACHMENT, conditionAttachOrgTypeCode, null));
//        }
//        //
//        if (CollectionUtils.isNotEmpty(nonSelectTableCodes)) {
//            MasterDataQueryTable queryTable = null;
//            for (MasterDataUniqueAttr nonSelectTableCode : nonSelectTableCodes) {
//                queryTable = MasterDataQueryUtils.getQueryTable(queryInternal, nonSelectTableCode);
//                if (queryTable != null) {
//                    MasterDataQueryUtils.setTableSelectAttr(queryTable, "X", false);
//                }
//            }
//        }
//    }
//
//
//    /**
//     * 内部转换，按需指定查询列
//     *
//     * @param context   查询上下文
//     * @param condition 查询条件
//     */
//    protected void parseQueryColumns(MasterDataQueryContext context, MasterDataQueryCondition condition, MasterDataQueryInternal queryInternal) throws BaseException {
//        if (condition.getMdQueryColumns() != null && condition.getMdQueryColumns().size() > 0) {
//            // 如果指定了查询列，则初始化全部默认不查询
//            for (MasterDataQueryTable mdQueryTable : condition.getMdQueryTables()) {
//                if ("Y".equals(mdQueryTable.getTableSelectEnabled())) {
//                    setQueryTableQueryColumnEnabled(mdQueryTable, "N", false);
//                }
//            }
//
//            // 设置指定的列可查询
//            MasterDataQueryTable queryTable = null;
//            Map<String, MasterDataQueryTableColumn> queryTableColumnMap = null;
//            List<MasterDataQueryTableColumn> queryTableColumns = null;
//            for (MasterDataQueryColumn queryColumn : condition.getMdQueryColumns()) {
//                // 如果是code子查询列，则忽略
//                queryTable = MasterDataQueryUtils.getQueryTableByMatchUnique(condition.getMdQueryTables(), queryColumn.getMatchUnique());
//                if (queryTable == null) {
//                    if (context.isCheckTableMatch()) {
//                        throw new MasterDataBaseException(MasterDataQueryMsgConsts.HMDM_CORE_QUEY_ERROR_006, new String[]{queryColumn.getMatchUnique()});
//                    }
//                    continue;
//                }
//                // 如果表状态为X，则列名指定有误
//                if ("X".equals(queryTable.getTableSelectEnabled())) {
//                    throw new MasterDataBaseException(MasterDataQueryMsgConsts.HMDM_CORE_QUEY_ERROR_007, new String[]{queryColumn.getMatchUnique()});
//                }
//                // 如果所有，则设置全部可查询
//                if (queryColumn.getColumnNames().contains(MasterDataQueryConstants.QUERY_ALL)) {
//                    // 排除一些不查询的字段
//                    boolean isWhoNone = queryColumn.getColumnNames().contains(MasterDataQueryConstants.QUERY_WHO_NONE);
//                    boolean isAttributeNone = queryColumn.getColumnNames().contains(MasterDataQueryConstants.QUERY_ATTRIBUTE_NONE);
//                    for (MasterDataQueryTableColumn tableColumn : queryTable.getQueryTableColumns()) {
//                        if (!"D".equals(tableColumn.getColumnSelectEnabled())) {
//                            if (tableColumn.isWhoColumn() && isWhoNone) {
//                                tableColumn.setColumnSelectEnabled("N");
//                            } else if (tableColumn.isAttributeColumn() && isAttributeNone) {
//                                tableColumn.setColumnSelectEnabled("N");
//                            } else {
//                                // 指定查询的字段，启用Code（含LOV，快码等）查询模式
//                                this.enabledColumnCodeQuery(queryColumn, tableColumn);
//                            }
//                        }
//                    }
//                    // 设置主数据表存在查询字段
//                    setQueryTableQueryColumnEnabled(queryTable, "Y", true);
//                } else {
//                    // 如果指定了代码子列信息查询，则需要把代码列补充进去
////                    Set<String> queryCodeColumns = queryColumn.getColumnNames().stream().filter(a -> a.contains(MasterDataQueryConstants.CODE_REF_SEPARATOR)).collect(Collectors.toSet());
////                    if (queryCodeColumns != null && queryCodeColumns.size() > 0){
////                        queryCodeColumns.stream().forEach(column -> {
////                            queryColumn.getColumnNames().add(column.substring(0, column.indexOf(MasterDataQueryConstants.CODE_REF_SEPARATOR)));
////                        });
////                    }
//
//                    // 将查询表列信息转换为Map
//                    queryTableColumnMap = queryTable.getQueryTableColumns().stream().collect(Collectors.toMap(MasterDataQueryTableColumn::getColumnAliasName, Function.identity()));
//                    // 强制设置ID字段为查询字段
//                    queryColumn.getColumnNames().add(MasterDataBaseConstants.FIELD_ID);
//                    // 如果在查询列中，则设置为可查询，否则，设置为不可查询
//                    Set<String> tableAliasSet = new HashSet<>();
//                    // 判断各种查询QueryAll
//                    if (queryColumn.getColumnNames().contains(MasterDataQueryConstants.QUERY_EXTEND_ALL)) {
//                        queryTableColumns = queryTable.getQueryTableColumns().stream().filter(a -> a.isExtendAttr()).collect(Collectors.toList());
//                        if (CollectionUtils.isNotEmpty(queryTableColumns)) {
//                            queryTableColumns.forEach(a -> {
//                                if (!"D".equals(a.getColumnSelectEnabled())) {
//                                    a.setColumnSelectEnabled("Y");
//                                }
//                            });
//                        }
//                    }
//                    if (queryColumn.getColumnNames().contains(MasterDataQueryConstants.QUERY_WHO_ALL)) {
//                        queryTableColumns = queryTable.getQueryTableColumns().stream().filter(a -> a.isWhoColumn()).collect(Collectors.toList());
//                        if (CollectionUtils.isNotEmpty(queryTableColumns)) {
//                            queryTableColumns.forEach(a -> {
//                                if (!"D".equals(a.getColumnSelectEnabled())) {
//                                    a.setColumnSelectEnabled("Y");
//                                }
//                            });
//                        }
//                    }
//                    if (queryColumn.getColumnNames().contains(MasterDataQueryConstants.QUERY_ATTRIBUTE_ALL)) {
//                        queryTableColumns = queryTable.getQueryTableColumns().stream().filter(a -> a.isAttributeColumn()).collect(Collectors.toList());
//                        if (CollectionUtils.isNotEmpty(queryTableColumns)) {
//                            queryTableColumns.forEach(a -> {
//                                if (!"D".equals(a.getColumnSelectEnabled())) {
//                                    a.setColumnSelectEnabled("Y");
//                                }
//                            });
//                        }
//                    }
//                    // 普通查询字段
//                    MasterDataQueryTableColumn queryTableColumn = null;
//                    for (String columnName : queryColumn.getColumnNames()) {
//                        queryTableColumn = queryTableColumnMap.get(columnName);
//                        if (queryTableColumn != null) {
//                            // 特殊的，如果属性的引用主数据值字段，则带出整个引用主数据LOV字段
//                            if (StringUtils.isNotBlank(queryTableColumn.getRefMdTableAlias())) {
//                                String refMdTableAlias = queryTableColumn.getRefMdTableAlias();
//                                queryTableColumns = queryTable.getQueryTableColumns().stream().filter(a -> a.getTableAliasName().equals(refMdTableAlias)
//                                        && !a.getColumnAliasName().contains(MasterDataQueryConstants.MD_REF_SEPARATOR)).collect(Collectors.toList());
//                                if (CollectionUtils.isNotEmpty(queryTableColumns)) {
//                                    queryTableColumns.forEach(a -> {
//                                        a.setColumnSelectEnabled("Y");
//                                    });
//                                }
//                                tableAliasSet.add(refMdTableAlias);
//                            }
//                            this.enabledColumnCodeQuery(queryColumn, queryTableColumn);
//                            tableAliasSet.add(queryTableColumn.getTableAliasName());
//                        }
//                    }
//                    // 设置表存在查询字段
//                    tableAliasSet.forEach(tableAlias -> {
//                        queryInternal.getTableAliasMap().get(tableAlias).setTableSelectEnabled("Y");
//                        queryInternal.getTableAliasMap().get(tableAlias).setHasQueryColumn(true);
//                    });
//                }
//            }
//        }
//    }
//
//    /**
//     * 转换查询限制条件
//     *
//     * @param context       查询上下文
//     * @param condition     查询条件
//     * @param conditionAttr 查询限制条件
//     */
//    protected void parseQueryRestriction(MasterDataQueryContext context, MasterDataQueryCondition condition,
//                                         MasterDataQueryInternal queryInternal, MasterDataConditionAttr conditionAttr)
//            throws MasterDataBaseException {
//        MasterDataQueryRestriction queryRestriction = new MasterDataQueryRestriction();
//        queryRestriction.setTableLevel(conditionAttr.getTableLevel());
//        MasterDataQueryTable queryTable = null;
//        MasterDataQueryTableColumn queryTableColumn = null;
//        // 如果不限制列信息，则认为是必须表的限制条件
//        queryTable = MasterDataQueryUtils.getQueryTable(queryInternal, conditionAttr);
//        if (StringUtils.isBlank(conditionAttr.getQueryColumn())) {
//            queryRestriction.setTableColumnName(null);
//            queryRestriction.setTableColumnDataType(null);
//            queryRestriction.setTableAliasName(queryTable.getTableAliasName());
//            queryRestriction.setColumnSelectEnabled(queryTable.getTableSelectEnabled());
//        } else {
//            queryTableColumn = MasterDataQueryUtils.getQueryTableColumn(queryTable, conditionAttr.getQueryColumn());
//            queryRestriction.setTableColumnName(queryTableColumn.getTableColumnName());
//            queryRestriction.setTableColumnDataType(queryTableColumn.getTableColumnDataType());
//            queryRestriction.setTableAliasName(queryTableColumn.getColumnTableAlias());// 设置为引用列所属表的表列名
//            queryRestriction.setColumnSelectEnabled(queryTableColumn.getColumnSelectEnabled());
//            // 如果表达式为空，则默认表达式设置为表别名+"."+表列名
//            if (StringUtils.isBlank(conditionAttr.getExpression())) {
//                queryRestriction.setExpression(queryTableColumn.getTableAliasName() + "." + queryTableColumn.getTableColumnName());
//            }
//        }
//        queryRestriction.setRestrictionType(conditionAttr.getQueryRestrictionType() == null ? "" : conditionAttr.getQueryRestrictionType());
//        queryRestriction.setValue(conditionAttr.getValue());
//        if (MasterDataQueryConstants.QUERY_CONDITION_TYPE_IN.equals(queryRestriction.getRestrictionType())) {
//            if (conditionAttr.getValue() instanceof Collection) {
//                // 只有一条记录的时候，转换为=
//                if (((Collection) conditionAttr.getValue()).size() == 1) {
//                    queryRestriction.setRestrictionType(MasterDataQueryConstants.QUERY_CONDITION_TYPE_EQUALS);
//                    queryRestriction.setValue(((Collection) conditionAttr.getValue()).toArray()[0]);
//                }
//            }
//        }
//
//        // 转换表达式
//        if (StringUtils.isNotBlank(conditionAttr.getExpression())) {
//            // 设置当前表映射
//            queryInternal.getTableMap().put(MasterDataQueryConstants.CONDITION_CURRENT_TABLE, queryRestriction.getTableAliasName());
//            // 对于复杂查询条件需要解析表达式
//            queryRestriction.setExpression(this.convertExpression(condition, queryInternal, conditionAttr.getExpression(), "QC"));
//            queryRestriction.setComplex(true);
//        } else {
//            queryTable.setHasQueryCondition(true);
//            // 如果字段来源是引用主数据，则也需要设置主数据标记为true
//            if (queryTableColumn != null) {
//                if (!queryTableColumn.getTableAliasName().equals(queryTableColumn.getColumnTableAlias())) {
//                    queryInternal.getTableAliasMap().get(queryTableColumn.getTableAliasName()).setHasQueryCondition(true);
//                }
//            }
//        }
//        // 如果不是Where限制条件，则认为是left join on条件
//        if (conditionAttr.isWhere()) {
//            condition.getMdQueryRestrictions().add(queryRestriction);
//        } else {
//            // join不作为查询限制条件
//            queryTable.setHasQueryCondition(false);
//            // 处理几种限制类型
//            if (StringUtils.isNotBlank(conditionAttr.getQueryRestrictionType()) && queryTableColumn != null) {
//                String joinRestriction = queryTableColumn.getTableAliasName() + "." + queryTableColumn.getTableColumnName();
//                joinRestriction = joinRestriction + " " + conditionAttr.getQueryRestrictionType();
//                if (conditionAttr.getValue() instanceof Collection) {
//                    joinRestriction = joinRestriction + " " + MasterDataQueryUtils.getInClause((Collection) conditionAttr.getValue());
//                } else if (conditionAttr.getValue() instanceof String) {
//                    joinRestriction = joinRestriction + " '" + conditionAttr.getValue().toString() + "'";
//                } else {
//                    joinRestriction = joinRestriction + " " + conditionAttr.getValue().toString();
//                }
//                queryRestriction.setExpression(joinRestriction);
//            }
//            queryTable.getTableJoins().add(new MasterDataQueryTableJoin(queryRestriction.getExpression()));
//        }
//    }
//
//    /**
//     * 内部转换限制条件
//     * 转换限制条件(where)集合
//     * 在列名相同的情况下，采用如下优先级匹配关系
//     * 1. 匹配层级完全一致的
//     * 2. 如果查询条件未指定层次，则补全在进行层级完全匹配
//     * 3. 列名无法匹配则直接报错
//     *
//     * @param context   查询上下文
//     * @param condition 查询条件
//     */
//    protected void parseRestrictions(MasterDataQueryContext context, MasterDataQueryCondition condition, MasterDataQueryInternal queryInternal) throws BaseException {
//        // 生成表与表别名映射信息
//        for (MasterDataQueryTable queryTable : condition.getMdQueryTables()) {
//            if (queryTable.getTableLevel().equals(MasterDataQueryConstants.TABLE_LEVEL_MD_ATTACHMENT)) {
//                queryInternal.getTableMap().put("{" + queryTable.getTableLevel() + "_" + queryTable.getOrgTypeCode() + "_TABLE}", queryTable.getTableAliasName());
//            } else if (queryTable.getTableLevel().equals(MasterDataQueryConstants.TABLE_LEVEL_MD_TABLE_ATTR)) {
//                queryInternal.getTableMap().put("{" + queryTable.getTableAttrCode() + "_TABLE}", queryTable.getTableAliasName());
//            } else if (queryTable.getTableLevel().equals(MasterDataQueryConstants.TABLE_LEVEL_MD_ORG)) {
//                queryInternal.getTableMap().put("{" + queryTable.getOrgTypeCode() + "_TABLE}", queryTable.getTableAliasName());
//            } else {
//                queryInternal.getTableMap().put("{" + queryTable.getTableLevel() + "_TABLE}", queryTable.getTableAliasName());
//            }
//        }
//        // 转换每个查询条件
//        for (MasterDataConditionAttr conditionAttr : condition.getMdConditionAttrs()) {
//            this.parseQueryRestriction(context, condition, queryInternal, conditionAttr);
//        }
//    }
//
//    /**
//     * 内部转换查询排序条件
//     *
//     * @param context   查询上下文
//     * @param condition 查询条件
//     * @throws MasterDataBaseException 主数据异常
//     */
//    protected void parseQueryOrder(MasterDataQueryContext context, MasterDataQueryCondition condition, MasterDataQueryInternal queryInternal) throws MasterDataBaseException {
//        MasterDataQueryTable queryTable = null;
//        MasterDataQueryTableColumn queryTableColumn = null;
//        if (condition.getMdQueryOrders() != null && condition.getMdQueryOrders().size() > 0) {
//            for (MasterDataQueryOrder queryOrder : condition.getMdQueryOrders()) {
//                queryTable = MasterDataQueryUtils.getQueryTable(queryInternal, queryOrder);
//                if (StringUtils.isBlank(queryOrder.getOrderExpression())) {
//                    queryTableColumn = MasterDataQueryUtils.getQueryTableColumn(queryTable, queryOrder.getTableColumnName());
//                    queryOrder.setTableAliasName(queryTableColumn.getTableAliasName());
//                    queryOrder.setColumnSelectEnabled(queryTableColumn.getColumnSelectEnabled());
//                    queryOrder.setOrderExpression(queryTableColumn.getTableAliasName() + "." + queryTableColumn.getTableColumnName() + " " + queryOrder.getOrderBy());
//                    queryTable.setHasQueryOrder(true);
//                } else {
//                    // 转换表达式
//                    // 设置当前表映射
//                    queryInternal.getTableMap().put(MasterDataQueryConstants.CONDITION_CURRENT_TABLE, queryTable.getTableAliasName());
//                    queryOrder.setOrderExpression(this.convertExpression(condition, queryInternal, queryOrder.getOrderExpression(), "QO"));
//                }
//            }
//        }
//    }
//
//
//    /**
//     * 内部转换关联表信息
//     *
//     * @param context   查询上下文
//     * @param condition 查询条件
//     */
//    protected void parseJoinTableInfo(MasterDataQueryContext context, MasterDataQueryCondition condition, MasterDataQueryInternal queryInternal) throws BaseException {
//        // 单表查询临时变量
//        int selectTableCount = 0;
//        int nonJoinTableCount = 0;
//        MasterDataQueryTable selectQueryTable = null;
//        MasterDataUniqueAttr innerQueryCode = null;
//        for (MasterDataQueryTable queryTable : condition.getMdQueryTables()) {
//            // 失效查询表
//            this.checkAndDisableQueryTable(queryTable);
//
//            // 如果未失效的则设置关联表信息
//            if (!"D".equals(queryTable.getTableSelectEnabled())) {
//                this.setJoinTableInfo(context, condition, queryInternal, queryTable);
//            }
//            // 启用查询的表，计数
//            if ("Y".equals(queryTable.getTableSelectEnabled())) {
//                selectQueryTable = queryTable;
//                selectTableCount++;
//
//                // 如果join表信息为空，计数，如果大于1，则直接报错
//                if (StringUtils.isBlank(queryTable.getJoinTableAliasName())) {
//                    nonJoinTableCount++;
//                }
//            }
//            // 判断table的join类型
//            innerQueryCode = MasterDataQueryUtils.getEnableInnerQueryCode(context, queryTable.getMatchUnique());
//            if (innerQueryCode != null) {
//                queryTable.setJoinType("INNER");
//            }
//        }
//
//        // 如果无join的表大于1，则直接报错
//        if (nonJoinTableCount > 1) {
//            throw new MasterDataBaseException(MasterDataQueryMsgConsts.HMDM_CORE_QUEY_ERROR_031);
//        }
//
//        // 优化关联关系，提升效率
//        this.optimizeJoinTableClause(condition);
//
//        // 如果启用单表查询，如果只有一个表，则去掉列名前缀
//        if (context.isEnableSingleTableNonPrex() && selectTableCount == 1) {
//            for (MasterDataQueryTableColumn tableColumn : selectQueryTable.getQueryTableColumns()) {
//                tableColumn.setColumnAliasExpression("");
//            }
//        }
//    }
//
//
//    /**
//     * 执行查询
//     *
//     * @param context       查询上下文
//     * @param condition     查询条件
//     * @param queryInternal 查询内部对象
//     */
//    protected List<Map<String, Object>> processQuery(MasterDataQueryContext context, MasterDataQueryCondition condition, MasterDataQueryInternal queryInternal) throws Exception {
//        List<Map<String, Object>> result = null;
//        Page page = null;
//        /**
//         * 增加solar查询，前提启用分页才用solr
//         * 1. 如果启用了查询solar Collection，则调用solar查询
//         * 2. 没有启用则采用普通查询
//         */
//        boolean solrQuery = false;
//        if (condition.getPageSize() > 0) {
//            if (context.getQueryStrategyType().equals(MasterDataQueryConstants.QUERY_STRATRGY_TYPE_MD)) {
//                condition.setCollection(context.getMasterDataType().getSolrCollection());
//            } else if (context.getQueryStrategyType().equals(MasterDataQueryConstants.QUERY_STRATRGY_TYPE_APPLY)) {
//                condition.setCollection(context.getMasterDataType().getSolrApplyCollection());
//            }
//            if (StringUtils.isNotBlank(condition.getCollection())) {
//                result = masterDataSolrQueryService.query(context, condition, queryInternal);
//                // 有结果才认为调用solr成功
//                if (condition.getTotal() != null && condition.getTotal() > 0) {
//                    solrQuery = true;
//                }
//            }
//        }
//        // 如果查询结果为空，则采用常规sql查询
//        if (CollectionUtils.isEmpty(result)) {
//            page = PageHelper.startPage(condition.getPage(), condition.getPageSize());
//            if (solrQuery) {
//                page.setCount(false);
//            }
//        } else {
//            // 如果是预分页(有且仅查询ID列)，可以直接返回solr查询结果，提升效率
//            if (condition.getPrePage().isEnabledFlag()) {
//                return result;
//            }
//        }
//        // 进行独立查询拆分
//        List<MasterDataSplitQueryCondition> splitConditions = this.splitQueryCondition(context, condition, queryInternal);
//        // 调用常规查询
//        result = masterDataQueryMapper.selectMasterDataByCondition(context, condition);
//        // 获取查询总数；如有预分页信息，以预分页信息为准
//        if (condition.getPrePage().getPageSize() > 0) {
//            condition.setPage(condition.getPrePage().getPage());
//            condition.setPageSize(condition.getPrePage().getPageSize());
//            condition.setTotal(condition.getPrePage().getTotal());
//        } else {
//            if (solrQuery) {
//                condition.setTotal(condition.getTotal());
//            } else if (page != null) {
//                condition.setTotal(page.getTotal());
//            }
//        }
//
//        // 调用拆分独立查询
//        if (CollectionUtils.isNotEmpty(splitConditions) && CollectionUtils.isNotEmpty(result)) {
//            this.processSplitQuery(context, condition, queryInternal, splitConditions, result);
//        }
//        // 返回查询结果
//        return result;
//    }
//
//    /**
//     * solr查询
//     *
//     * @param context 查询上下文
//     * @param condition 查询条件
//     * @param queryInternal 查询内部对象
//     * @return solr查询结果
//     * @throws BaseException 基本异常
//     */
//    @Override
//    public List<Map<String, Object>> query(MasterDataQueryContext context, MasterDataQueryCondition condition, MasterDataQueryInternal queryInternal) throws BaseException {
//        List<Map<String, Object>> solrResult = null;
//        // 无复杂查询则不进行solr查询
//        if (CollectionUtils.isEmpty(condition.getSolrConditionAttrs())){
//            return solrResult;
//        }
//        SolrQueryContext solrQueryContext = new SolrQueryContext();
//        // 查询启用查询的表信息
//        List<MasterDataQueryTable> selectTables = condition.getMdQueryTables().stream().filter(a -> "Y".equals(a.getTableSelectEnabled())).collect(Collectors.toList());
//        if (CollectionUtils.isEmpty(selectTables)){
//            throw new MasterDataBaseException(MasterDataQueryMsgConsts.HMDM_CORE_QUEY_ERROR_024);
//        }
//        // 启用solr查询的表，取最细层级的查询表
//        MasterDataQueryTable solrTable = null;
//        for (MasterDataQueryTable queryTable: selectTables){
//            if ((solrTable == null)
//                    || (tableLevelMap.get(queryTable.getTableLevel()) > tableLevelMap.get(solrTable.getTableLevel()))) {
//                solrTable = queryTable;
//            }
//        }
//        // 判断solr查询表是否符合规则，必须是solr支持的层级内
//        int solrTableLevelId = tableLevelMap.get(solrTable.getTableLevel());
//        if (solrTableLevelId > SOLR_SUPPORT_TABLE_LEVEL_ID){
//            return solrResult;
//        }
//        // 获取solr查询条件层级
//        boolean isGroupBy = false;
//        Set<String> restTableLevels = new HashSet<>();
//        if (CollectionUtils.isNotEmpty(condition.getMdConditionAttrs())) {
//            condition.getMdConditionAttrs().forEach(conditionAttr -> restTableLevels.add(conditionAttr.getTableLevel()));
//        }
//        if (CollectionUtils.isNotEmpty(condition.getSolrConditionAttrs())) {
//            condition.getSolrConditionAttrs().forEach(conditionAttr -> restTableLevels.add(conditionAttr.getTableLevel()));
//        }
//        String minSolrRestTableLevel = "";
//        for (String restTableLevel: restTableLevels){
//            if (StringUtils.isBlank(minSolrRestTableLevel)
//                    || tableLevelMap.get(restTableLevel) > tableLevelMap.get(minSolrRestTableLevel)){
//                minSolrRestTableLevel = restTableLevel;
//            }
//        }
//        // solr查询条件是否符合规则，必须是solr支持的层级内
//        int minSolrRestTableLevelId = tableLevelMap.get(minSolrRestTableLevel);
//        if (minSolrRestTableLevelId > SOLR_SUPPORT_TABLE_LEVEL_ID){
//            return solrResult;
//        }
//        // 如果solr查询条件层级大于solr查询表层级，则需要group by
//        if (minSolrRestTableLevelId > solrTableLevelId){
//            isGroupBy = true;
//        }
//        /*
//        else {
//            // 如果查询策略是MD，且查询表层级是MD，则强制执行group by；解决无组织的主数据查询问题
//            if (context.getQueryStrategyType().equals(MasterDataQueryConstants.TABLE_LEVEL_MD) && solrTable.getTableLevel().equals(MasterDataQueryConstants.TABLE_LEVEL_MD)){
//                isGroupBy = true;
//            }
//        }
//        */
//        /**
//         * 生成solr限制条件
//         * 1. 直接从限制条件获取，筛选简单条件，即无复杂表达式的条件
//         * 2. 从solr限制条件获取，主要是针对复杂查询条件
//         * 3 判断是否启用solr返回结果：1. 存在like, 2. 存在复杂查询
//         */
//        if (CollectionUtils.isNotEmpty(condition.getMdQueryRestrictions())){
//            condition.getMdQueryRestrictions().forEach(rest -> {
//                if (!rest.isComplex()){
//                    condition.getSolrQueryRestrictions().add(rest);
//                    if (MasterDataQueryConstants.QUERY_CONDITION_TYPE_LIKE.equals(rest.getRestrictionType())){
//                        solrQueryContext.setGetResult(true);
//                    }
//                }
//            });
//        }
//        MasterDataQueryRestriction solrQueryRestriction = null;
//        MasterDataQueryTableColumn solrQueryTableColumn = null;
//        MasterDataQueryTable solrQueryTable = null;
//        if (CollectionUtils.isNotEmpty(condition.getSolrConditionAttrs())){
//            for (MasterDataConditionAttr solrConditionAttr: condition.getSolrConditionAttrs()){
//                if (solrConditionAttr.getValue() == null){
//                    throw new MasterDataBaseException(MasterDataQueryMsgConsts.HMDM_CORE_QUEY_ERROR_026, new String[]{solrConditionAttr.getQueryColumn()});
//                }
//                solrQueryTable = MasterDataQueryUtils.getQueryTable(queryInternal, solrConditionAttr);
//                solrQueryTableColumn = MasterDataQueryUtils.getQueryTableColumn(solrQueryTable, solrConditionAttr.getQueryColumn());
//                solrQueryRestriction = new MasterDataQueryRestriction();
//                solrQueryRestriction.setTableColumnName(solrQueryTableColumn.getTableColumnName());
//                solrQueryRestriction.setTableColumnDataType(solrQueryTableColumn.getTableColumnDataType());
//                solrQueryRestriction.setTableAliasName(solrQueryTableColumn.getColumnTableAlias());// 设置为引用列所属表的表列名
//                solrQueryRestriction.setColumnSelectEnabled(solrQueryTableColumn.getColumnSelectEnabled());
//                solrQueryRestriction.setRestrictionType(solrConditionAttr.getQueryRestrictionType());
//                solrQueryRestriction.setValue(solrConditionAttr.getValue());
//                if (MasterDataQueryConstants.QUERY_CONDITION_TYPE_IN.equals(solrQueryRestriction.getRestrictionType())){
//                    if (solrConditionAttr.getValue() instanceof Collection){
//                        // 只有一条记录的时候，转换为=
//                        if (((Collection) solrConditionAttr.getValue()).size() == 1){
//                            solrQueryRestriction.setRestrictionType(MasterDataQueryConstants.QUERY_CONDITION_TYPE_EQUALS);
//                            solrQueryRestriction.setValue(((Collection) solrConditionAttr.getValue()).toArray()[0]);
//                        }
//                    }
//                }
//                condition.getSolrQueryRestrictions().add(solrQueryRestriction);
//            }
//            solrQueryContext.setGetResult(true);
//        }
//        // 判断solr限制条件是否有缺失：solr限制条件必须要大于等于sql查询条件数，防止部分复杂限制条件没有加对应的solr查询条件
//        if (condition.getSolrQueryRestrictions().size() < condition.getMdQueryRestrictions().size()){
//            throw new MasterDataBaseException(MasterDataQueryMsgConsts.HMDM_CORE_QUEY_ERROR_025);
//        }
//        // 生成solr查询上下文
//        solrQueryContext.setSolrQueryTable(solrTable).setGroupBy(isGroupBy).setGroupByField(MasterDataBaseConstants.FIELD_ID);
//        try {
//            solrResult =  fuzzySearchService.solrQuery(condition, solrQueryContext);
//            // 如果查询结果集为空，则返回false，采用常规sql查询
//            if (CollectionUtils.isEmpty(solrResult)){
//                return solrResult;
//            }
//            List<Long> solrResultIds = new ArrayList<>();
//            solrResult.forEach(map -> solrResultIds.add((Long)map.get(MasterDataBaseConstants.FIELD_ID)));
//            // 将查询限制条件替换为solr结果集
//            condition.getMdQueryRestrictions().clear();
//            MasterDataQueryRestriction solrResultRestriction = new MasterDataQueryRestriction();
//            solrResultRestriction.setTableColumnName(MasterDataBaseConstants.FIELD_ID);
//            solrResultRestriction.setTableColumnDataType("INTEGER");
//            solrResultRestriction.setTableAliasName(solrTable.getTableAliasName());
//            solrResultRestriction.setColumnSelectEnabled(solrTable.getTableSelectEnabled());
//            solrResultRestriction.setRestrictionType(MasterDataQueryConstants.QUERY_CONDITION_TYPE_IN);
//            solrResultRestriction.setValue(solrResultIds);
//            solrResultRestriction.setExpression(solrResultRestriction.getTableAliasName() + "." + solrResultRestriction.getTableColumnName());
//            condition.getMdQueryRestrictions().add(solrResultRestriction);
//            return solrResult;
//        } catch (IOException e) {
//            if (logger.isErrorEnabled()) {
//                logger.error("solrQuery error-IOException," + e.getMessage());
//            }
//        } catch (SolrServerException e) {
//            if (logger.isErrorEnabled()) {
//                logger.error("solrQuery error-SolrServerException," + e.getMessage());
//            }
//        } catch (Exception e) {
//            if (logger.isErrorEnabled()) {
//                logger.error("solrQuery error-Exception," + e.getMessage());
//            }
//        }
//        return solrResult;
//    }
//
//
//
//}
